numberFuncs.sqrt - Code Metrics - Inspection of "minor fixes" - nightfury7/universalbasics.js - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 8d43c8...457e33 )

by Night
created 2018-07-24 14:10 UTC
numberFuncs.sqrt A

↳ Parent: src/ub.numbers.js
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	1	Features	1
Metric	Value
cc	1
eloc	3
c	1
b	1
f	1
nc	1
nop	0
dl	0
loc	4
rs	10
/** global: UB */

UB.intMaxValue = 2147483647;
UB.intMinValue = -2147483648;
UB.floatMaxValue = 3.40282e+038; /// 038 or 056? .. it was originally 038F
UB.floatMinValue = -3.40282e+038;
UB.doubleMaxValue =  9223372036854775807;
UB.doubleMinValue = -9223372036854775808;

UB.roman1s = ["", "i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix"];
UB.roman10s = ["", "x", "xx", "xxx", "xl", "l", "lx", "lxx", "lxxx", "xc"];
UB.roman100s = ["", "c", "cc", "ccc", "cd", "d", "dc", "dcc", "dccc", "cm"];
UB.roman1000s = ["", "m", "mm", "mmm", "mmmm", "", "", "", "", ""];
UB.roman = [UB.roman1s, UB.roman10s, UB.roman100s, UB.roman1000s];

UB.letterLegal = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA", "BB", "CC", "DD", "EE", "FF", "GG", "HH", "II", "JJ", "KK", "LL", "MM", "NN", "OO", "PP", "QQ", "RR", "SS", "TT", "UU", "VV", "WW", "XX", "YY", "ZZ", "AAA", "BBB", "CCC", "DDD", "EEE", "FFF", "GGG", "HHH", "III", "JJJ", "KKK", "LLL", "MMM", "NNN", "OOO", "PPP", "QQQ", "RRR", "SSS", "TTT", "UUU", "VVV", "WWW", "XXX", "YYY", "ZZZ", "AAAA", "BBBB", "CCCC", "DDDD", "EEEE", "FFFF", "GGGG", "HHHH", "IIII", "JJJJ", "KKKK", "LLLL", "MMMM", "NNNN", "OOOO", "PPPP", "QQQQ", "RRRR", "SSSS", "TTTT", "UUUU", "VVVV", "WWWW", "XXXX", "YYYY", "ZZZZ", "AAAAA", "BBBBB", "CCCCC", "DDDDD", "EEEEE", "FFFFF", "GGGGG", "HHHHH", "IIIII", "JJJJJ", "KKKKK", "LLLLL", "MMMMM", "NNNNN", "OOOOO", "PPPPP", "QQQQQ", "RRRRR", "SSSSS", "TTTTT", "UUUUU", "VVVVV", "WWWWW", "XXXXX", "YYYYY", "ZZZZZ"];
UB.letterExcel = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "AA", "AB", "AC", "AD", "AE", "AF", "AG", "AH", "AI", "AJ", "AK", "AL", "AM", "AN", "AO", "AP", "AQ", "AR", "AS", "AT", "AU", "AV", "AW", "AX", "AY", "AZ", "BA", "BB", "BC", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BK", "BL", "BM", "BN", "BO", "BP", "BQ", "BR", "BS", "BT", "BU", "BV", "BW", "BX", "BY", "BZ", "CA", "CB", "CC", "CD", "CE", "CF", "CG", "CH", "CI", "CJ", "CK", "CL", "CM", "CN", "CO", "CP", "CQ", "CR", "CS", "CT", "CU", "CV", "CW", "CX", "CY", "CZ", "DA", "DB", "DC", "DD", "DE", "DF", "DG", "DH", "DI", "DJ", "DK", "DL", "DM", "DN", "DO", "DP", "DQ", "DR", "DS", "DT", "DU", "DV", "DW", "DX", "DY", "DZ"];

UB.decZeros = "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
UB.hexChars = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f"];
UB.toDegrees = (180 / Math.PI);
UB.toRadians = (Math.PI / 180);

UB.minOf3 = function(num1, num2, num3){
	if (num1 < num2) {
		if (num1 < num3) {
			return num1;
		}
		return num3;
	}
	if (num2 < num3) {
		return num2;
	}
	return num3;
};
UB.maxOf3 = function(num1, num2, num3){
	if (num1 > num2) {
		if (num1 > num3) {
			return num1;
		}
		return num3;
	}
	if (num2 > num3) {
		return num2;
	}
	return num3;
};

UB.minOf4 = function(num1, num2, num3, num4){
	if (num1 < num2) {
		
		// 1, 3, 4
		if (num1 < num3) {
			
			// 1, 4
			if (num1 < num4) {
				return num1;
			}
			return num4;
		}
		
		// 3, 4
		if (num3 < num4) {
			return num3;
		}
		return num4;
		
	}
	
	// 2, 3, 4
	if (num2 < num3) {
		
		// 2, 4
		if (num2 < num4) {
			return num2;
		}
		return num4;
	}
	
	// 3, 4
	if (num3 < num4) {
		return num3;
	}
	return num4;
};
UB.maxOf4 = function(num1, num2, num3, num4){
	if (num1 > num2) {
		
		// 1, 3, 4
		if (num1 > num3) {
			
			// 1, 4
			if (num1 > num4) {
				return num1;
			}
			return num4;
		}
		
		// 3, 4
		if (num3 > num4) {
			return num3;
		}
		return num4;
		
	}
	
	// 2, 3, 4
	if (num2 > num3) {
		
		// 2, 4
		if (num2 > num4) {
			return num2;
		}
		return num4;
		
	}
	
	// 3, 4
	if (num3 > num4) {
		return num3;
	}
	return num4;
};

/** calc overlap of 2 numeric ranges */
UB.overlap = function(value1Start, value1End, value2Start, value2End){
	
	// swap if reversed
	if (value1Start > value1End) {
		var temp = value1Start;
		value1Start = value1End;
		value1End = temp;
	}
	if (value2Start > value2End) {
		temp = value2Start;
		value2Start = value2End;
		value2End = temp;
	}
	
	// exit if no overlap
	if (value1End < value2Start || value2End < value1Start) {
		return 0;
	}
	
	// return overlap of 2 ranges
	if (value1Start >= value2Start && value1End <= value2End) {
		return (value1End - value1Start);
	} else if (value2Start >= value1Start && value2End <= value1End) {
		return (value2End - value2Start);
	} else if (value1Start < value2Start && value1End <= value2End) {
		return (value1End - value2Start);
	} else if (value2Start < value1Start && value2End <= value1End) {
		return (value2End - value1Start);
	}
	return 0;
};

// distance between 2 lat/lon coords
UB.latLonDistance = function(latitude1, longitude1, latitude2, longitude2){
	
	// all lat/lons are floating point numbers in degrees
	
	var theta = longitude1 - longitude2;
	var miles = (Math.sin(latitude1*UB.toRadians)*Math.sin(latitude2*UB.toRadians)) + (Math.cos(latitude1*UB.toRadians)*Math.cos(latitude2*UB.toRadians)*Math.cos(theta*UB.toRadians));
	miles = Math.acos(miles);
	miles = (miles * UB.toDegrees);
	
	miles = miles * 60 * 1.1515;
	var feet = miles*5280;
	var yards = feet / 3;
	var kilometers = miles*1.609344;
	var meters = kilometers*1000;
	return [miles, feet, yards, kilometers, meters];
};
	

var stringFuncs = {
	
	/** CONVERT LEGAL LETTER TO NUMBER .. A = 1, B = 2, C = 3  */
	legalNumeralToNumber: function(zeroBased){
		var s = this.toString();
		return UB.letterLegal.indexOf(s.toUpperCase()) + (zeroBased ? 0 : 1);
	},
	/** CONVERT EXCEL COLUMN ID TO NUMBER .. A = 1, B = 2, C = 3  */
	excelColumnToNumber: function(zeroBased = false){
		var s = this.toString();
		return UB.letterExcel.indexOf(s.toUpperCase()) + (zeroBased ? 0 : 1);
	},
	
	hexToDecimal: function(onlyDigits = 0){
		var hex = this.toString();
		hex = hex.toUpperCase();
		
		// remove prefix
		if (hex.indexOf("0X") === 0){
			hex = hex.substr(2);
		}else if (hex.charAt(0) == "#"){
			hex = hex.substr(1);
		}
		
		if (onlyDigits) {
			hex = hex.substr(0, onlyDigits);
		}
		return int("0x" + hex);
	},
	
	binaryToDecimal: function(){
		var bin = this.toString();
		var num = bin.toString();

		bin = bin.toUpperCase();
		
		// remove prefix
		if (bin.indexOf("0B") === 0){
			bin = bin.substr(2);
		}
		
		var byte = 0;
		for (var i = 0, il = bin.length, il2 = bin.length - 1;i<il;i++){
			byte += uint(bin.charAt(il2 - i)) * Math.pow(2,i);
		}
		return byte;
	},
	
	none:null
};

// register funcs
UB.registerFuncs(String.prototype, stringFuncs);



var numberFuncs = {
	
	isOdd: function(){
		var val = this;
		return (val % 2) != 0;
	},
	isEven: function(){
		var val = this;
		return (val % 2) === 0;
	},
	isPositive: function(){
		var val = this;
		return (val > 0);
	},
	isNegative: function(){
		var val = this;
		return (val < 0);
	},
	relativeTo: function(v2, type){

		var v1 = this;
		// type .. 0=any, 1=pos, 2=neg
		var v = v2 - v1;
		if (type == 1) {
			return v > 0 ? v : -v;
		}else if (type == 2) {
			return v > 0 ? -v : v;
		}
		return v;
	},
	round: function(){
		return Math.round(this);
	},
	ceil: function(){
		return Math.ceil(this);
	},
	floor: function(){
		return Math.floor(this);
	},
	abs: function(negative = false){
		var v = this;
		if (negative){
			return v > 0 ? -v : v;
		}
		return v > 0 ? v : -v;
	},
	acos: function(degrees = false){
		var v = this;
		if (degrees) {
			return Math.acos(v) * UB.toDegrees;
		}
		return Math.acos(v);
	},
	asin: function(degrees = false){
		var v = this;
		if (degrees) {
			return Math.asin(v) * UB.toDegrees;
		}
		return Math.asin(v);
	},
	atan: function(degrees = false){
		var v = this;
		if (degrees) {
			return Math.atan(v) * UB.toDegrees;
		}
		return Math.atan(v);
	},
	atan2: function(x, degrees = false){
		var y = this;
		if (degrees) {
			return Math.atan2(y, x) * UB.toDegrees;
		}
		return Math.atan2(y, x);
	},
	exp: function(){
		var v = this;
		return Math.exp(v);
	},
	log: function(){
		var v = this;
		return Math.log(v);
	},
	pow: function(power){
		var base = this;
		return Math.pow(base, power)
	},
	sin: function(degrees = false){
		var angle = this;
		if (degrees) {
			return Math.sin(angle * UB.toRadians);
		}
		return Math.sin(angle);
	},
	cos: function(degrees = false){
		var angle = this;
		if (degrees) {
			return Math.cos(angle * UB.toRadians);
		}
		return Math.cos(angle);
	},
	tan: function(degrees = false){
		var angle = this;
		if (degrees) {
			return Math.tan(angle * UB.toRadians);
		}
		return Math.tan(angle);
	},
	sqrt: function(){
		var v = this;
		return Math.sqrt(v);
	},
	compare: function(v2){
		var v1 = this;
		if (v1 < v2) {
			return -1;
		}
		if (v1 > v2) {
			return 1;
		}
		return 0;
	},
	positive: function(){
		var val = this;
		return val > 0 ? val : -val;
	},
	negative: function(){
		var val = this;
		return val > 0 ? -val : val;
	},
	
	exists: function(zeroOK = false){
		var v = this;
		if (zeroOK) {
			return (v != null && v == v);
		}
		return v != null && v == v && v != 0;
	},
	
	
	min: function(num2){
		var num1 = this;
		if (num1 < num2) {
			return num1;
		}
		return num2;
	},
	max: function(num2){
		var num1 = this;
		if (num1 > num2) {
			return num1;
		}
		return num2;
	},
	atMost: function(limit){
		var num = this;
		return num > limit ? limit : num;
	},
	atLeast: function(limit){
		var num = this;
		return num < limit ? limit : num;
	},
	
	
	isNear: function(target, near = 1){
		var val = this;
		return val >= (target - near) && val <= (target + near);
	},
	

	/** Render a percentage (25%) using 2 values */
	percentageToString: function(current, decimals = 0){
		var total = this;
		return ((current / total) * 100).roundTo(decimals) + "%";
	},
	

	// CONVERT TO ABBREVIATION .. 1.5K
	toAbbreviation: function(decimals = 1){
		var num = this;
		if (num < 0) {
			return "-" + (-num).toAbbreviation; // -5.2K, -5.2M ..
		}
		if (num < 1000) {
			return String(num); // 520
		}
		if (num < 1000000) {
			return (num / 1000).roundToDigits(decimals) + 'K'; // 5.2K
		}
		if (num < 1000000000) {
			return (num / 1000000).roundToDigits(decimals) + 'M'; // 5.2M
		}
		return (num / 1000000000).roundToDigits(decimals) + 'G'; // 5.2B
	},
	
	
	// CONVERT TO ROMAN
	toRomanNumeral: function(){
		var n = this;
		if (n < 1) {
			n = 1;
		}
		
		// exit quickly if single digit
		if (n <= 9) {
			return UB.roman1s[n];
		}
		
		// create roman number if longer
		var str = n.toString();
		var output = [];
		for (var n = 0, nl = str.length;n<nl;n++){

			var series = ((nl - 1) - n);
			var charIndex = int(str.charAt(n));
			output.push(UB.roman[series][charIndex]);
		}
		return output.join("");
	},
	
	/** CONVERT TO LEGAL LETTER .. 1 = A, 2 = B, 3 = C .. AA, BB, CC */
	toLegalNumeral: function(){
		var n = this;
		if (n < 1) {
			n = 1;
		}
		return UB.letterLegal[n];
	},
	// CONVERT TO NORMAL LETTER .. A, B, C .. AB, AB, AC .. BA, BB, BC
	toLetterNumeral: function(){
		var n = this;
		if (n <= 26) {
			return UB.letterLegal[n];
		}
		return "?";
	},
	/** CONVERT TO EXCEL COLUMN ID .. 1 = A, 2 = B, 3 = C .. AA, AB, AC */
	toExcelColumn: function(zeroBased = false){
		var n = this;
		var min = zeroBased?0:1;
		if (n < min) {
			n = min;
		}
		return UB.letterExcel[zeroBased ? n : n-1];
	},
	
	// CONVERT TO ORDINAL FORMAT .. 1st, 2nd, 3rd
	toOrdinal: function(){
		var i = this;
		var j = i % 10;
		var k = i % 100;
		if (j == 1 && k != 11) {
			return i + "st";
		}
		if (j == 2 && k != 12) {
			return i + "nd";
		}
		if (j == 3 && k != 13) {
			return i + "rd";
		}
		return i + "th";
	},
	
	
	// OR
	or: function(returnVal, ifNull = 0){
		var n = this;
		if (n == ifNull) {
			return returnVal;
		}
		return n;
	},
	
	
	/** Calc padding for a given length */
	padding: function(multipleOf){
		var length = this;
		return (multipleOf - (length % multipleOf));
	},
	
	multipleOf: function(multipleOf){
		var value = this;
		return value + (multipleOf - (value % multipleOf));
	},
	
	
	// FROM C#
	
	distance: function(n2){
		var n1 = this;
		return Math.abs(n1 - n2);
	},
	
	/** Calc x % of the given value */
	percentage: function(percentWanted){
		var val100Percent = this;
		if (percentWanted == 100) {
			return val100Percent;
		}
		return val100Percent * (percentWanted / 100.0);
	},
	
	/** Calc the % of otherVal in relation to val100Percent */
	percentOf: function(otherVal){
		var val100Percent = this;
		return (otherVal / val100Percent) * 100.0;
	},
	
	/** Calc the difference between 2 numbers in %
	//  ... 100, 50 shows -50% difference
	//  ... 100, 150 shows 50% difference */
	percentDifference: function(otherVal){
		var val100Percent = this;
		return ((otherVal - val100Percent) / val100Percent) * 100.0;
	},
	
	isConsequetive: function(value, value2){
		return value2 == (value - 1) || value2 == (value + 1);
	},
	
	/** Returns the number halfway between the 2 given numbers
		Value1 can be greater than Value2. */
	between: function(value2){
		return this.middle(value2);
	},
	
	/** Returns the number halfway between the 2 given numbers
		Value1 can be greater than Value2. */
	middle: function(value2){
		var value1 = this;
		if (value1 > value2) {
			return value2 + ((value1 - value2) / 2);
		}
		return value1 + ((value2 - value1) / 2);
	},
	
	calcScale: function(targetValue){
		var value = this;
		if (targetValue === 0 && value === 0) {
			return 0;
		}
		return (value / targetValue);
	},
	
	ensure: function(defaultVal){
		var value = this;
		if (value === 0) {
			return defaultVal;
		}
		return value;
	},
	
	snapToHigher: function(snapBy){
		var val = this;
		return Math.ceil(val / snapBy) * snapBy;
	},
	snapToLower: function(snapBy){
		var val = this;
		return Math.floor(val / snapBy) * snapBy;
	},
	snapToNearest: function(snapBy){
		var val = this;
		return Math.round(val / snapBy) * snapBy;
	},
	
	toInt: function(round){
		var num = this;
		if (!round || round == "truncate") {
			return parseInt(num);
		}
		if (round == "round") {
			return Math.round(num);
		}
		if (round == "floor") {
			return Math.floor(num);
		}
		if (round == "ceiling") {
			return Math.ceil(num);
		}
		return 0;
	},
	
	/**
	 * Formats a Number adding commas and the specified decimal digits.
	 * Supports the million/billion and lakh/crore system.
	 * 
	 * @param	system					"million" or "lakh"
	 * @param	decimals				-1 = keep exact decimals as number, 0 = no decimals, 1+ = specific decimals
	 * @param	alwaysShowDecimal		add decimal even if decimal part is 0
	 */
	formatNumber: function(system, decimals = -1, alwaysShowDecimal = false){
		var num = this;
		
		var commas = system == "lakh" ? 2 : 3;

		// test if number is negative
		var neg = false;
		if (num < 0) {
			neg = true;
			num = -num;
		}
		// get the left number
		var numStr = String(num);
		var hasDot = numStr.indexOf(".")>-1;
		if (hasDot) {
			var parts = numStr.split(".");
			var whole = parts[0];
			var decimal = parts[1];
		}else{
			whole = numStr;
			decimal = null;
		}
		
		// if at least 4 digits
		if (whole.length > 3) {
			
			// extract 3 digits first 
			var wholeRight3 = whole.substr(whole.length - 3, 3);
			whole = whole.substr(0, whole.length - 3);			
			
			// add million / crore seperators
			if (whole.length < commas) {
				whole = whole + "," + wholeRight3;
			}else {
				var thou = "";
				var rem = whole.substr(0, int(whole.length % commas));
				var l = ((int(whole.length / commas)*commas) - commas) + (whole.length % commas);
				for (var c = 0;l >= 0;l -= commas, c++){

					thou = whole.substr(l, commas) + (c === 0 ? "" : ",") + thou;
				}
				whole = (rem == "" ? "" : rem + ",") + thou + "," + wholeRight3;
			}
		}
		
		// return with or without dot
		var result = whole;
		if (hasDot) {
			if (decimals > 0) {
				//  4.200
				result = whole + "." + decimal.substr(0, decimals).padRight("0", decimals);
			}else if (decimals === 0) {
				//  4
				result = whole;
			}else if (decimals === -1) {
				//  4.2
				result = whole + "." + decimal;
			}
			
		}else if (alwaysShowDecimal && decimals > 0) {
			
			//  4.0000
			result = whole + "." + decimals.repeat("0");
		}else {
			
			//  4
			result = whole;
		}
		return (neg ? "-" + result : result);
	},
	
	ensureNotNaN: function(instead = 0){
		var val = this;
		if (val != val) { /// fast isNaN check
			return instead;
		}
		return val;
	},
	
	isNaN: function(){
		var val = this;
		return val != val || isNaN(val);
	},
	
	isAny: function(haystacks, asInt = false, fractionalDigits = -1){
		var needle = this;
		
		// return true if any haystack equals the needle
		for (var s = 0, sl = haystacks.length;s<sl;s++){
			var num = haystacks[s];
			
			// simplify value for comparison
			if (asInt) {
				num = int(num);
			}else if(fractionalDigits != -1) {
				num = num.roundToDigits(fractionalDigits);
			}
			
			if (needle == num) {
				return true;
			}
		}
		return false;
	},
	
	scale: function(inputMin, inputMax, outputMin, outputMax, outputLimit = true, outputFlip = false){
		var input = this;
		
		// ensure input within limits
		if (input < inputMin) {
			input = inputMin;
		}
		if (input > inputMax) {
			input = inputMax;
		}
		
		// convert input to %
		var percent = ((1*(input - inputMin)) / (inputMax - inputMin));
		
		// convert % to output
		var output = (percent*(outputMax - outputMin)) + outputMin;
		
		// ensure output within limits
		if (outputLimit){
			if (output < outputMin) {
				output = outputMin;
			}
			if (output > outputMax) {
				output = outputMax;
			}
		}
		
		// flip output
		if (outputFlip) {
			output = ((outputMax - outputMin) - (output - outputMin)) + outputMin;
		}
		
		// return scaled, limit-checked output
		return output;
	},
	smartScale: function(inputMin, inputMax, outputMin, outputMax){
		var input = this;
		if (inputMin > inputMax) {
			if (outputMin > outputMax) {
				return input.flipWithin(inputMin, inputMax).scale(inputMax, inputMin, outputMax, outputMin, true, true);
			}
			return input.flipWithin(inputMin, inputMax).scale(inputMax, inputMin, outputMin, outputMax);
		}
		if (outputMin > outputMax) {
			return input.scale(inputMin, inputMax, outputMax, outputMin, true, true);
		}
		return input.scale(inputMin, inputMax, outputMin, outputMax);
	},
	
	flipWithin: function(min, max){
		var input = this;
		if (max < min) {
			return ((min - max) - (input - max)) + min;
		}
		return ((max - min) - (input - min)) + min;
	},
	
	limitToDigits: function(digits){
		var input = this;
		return parseFloat(input.toString().substr(0, digits));
	},
	limit: function(min, max){

		var input = this;
		
		// ensure ok
		if (input != input) { /// fast isNaN check
			return min;
		}
		
		// flip limits if in reverse order
		if (min > max) {
			var temp = max;
			max = min;
			min = temp;
		}
		
		// ensure within limits
		if (input < min) {
			return min;
		}else if (input > max) {
			return max;
		}
		return input;
	},
	limitToArray: function(array, extraMax = 0, extraMin = 0){
		var pointer = this;
		if (pointer <= -extraMin) {
			return -extraMin;
		}
		var last = (array.length + extraMax) - 1;
		if (last === -1) {
			return -extraMin;
		}else if (pointer > last) {
			return last;
		}
		return pointer;
	},
	
	wrap: function(min, max){
		var value = this;
		value -= min;
		var diff = (max - min) + 1;
		while (value < 0) {
			value += diff;
		}
		return min + (value % diff);
	},
	wrap2: function(min, max){

		var input = this;
		
		// flip limits if in reverse order
		if (min > max) {
			var temp = max;
			max = min;
			min = temp;
		}
		
		// ensure wrapped to limits
		var diff = (max - min) + 1;
		while (input < min) {
			input += diff;
		}
		while (input > max) {
			input -= diff;
		}
		return input;
	},
	wrapToMax: function(max){
		var value = this;
		var diff = max + 1;
		while (value < 0) {
			value += diff;
		}
		return value % diff;
	},
	
	/** Identical to modulo operator, except negative values are also supported, and brought into positive range.
		Value will never reach limit, just like the modulo operator.
		Simpler than `wrap` which takes `min` and `max`. */
	modulo: function(limit){
		var input = this;
		
		// ensure wrapped to limits
		while (input < 0) {
			input += limit;
		}
		while (input >= limit) {
			input -= limit;
		}
		return input;
	},
	
	roundToDigits: function(decimals = 4){
		var input = this;
		
		if (decimals <= 0) {
			return Math.round(input);
		}
		
		// Returns a number rounded to specified number of decimals
		var multiplier = Math.pow(10, decimals);
		return Math.round(input*multiplier)/multiplier;
	},
	roundTo: function(decimals){
		var input = this;
		
		// Returns a number rounded to specified number of decimals
		// Add zeros to always return those many decimals
		var num = input.roundToDigits(decimals).toString();
		if (decimals <= 0) {
			return num;
		}
		var add0 = 0;
		if (num.lastIndexOf(".") === -1){
			num = num+".";
			add0 = decimals;
		}else{
			add0 = decimals - ((num.length - num.lastIndexOf(".")) - 1);
		}
		while(add0 > 0){
			num = num+"0";
			add0 --;
		}
		return num;
	},
	
	
	// CHECKS
	/** Checks if the value is within min and max (supporting inclusive/exclusive modes) */
	isWithin: function(min, max, inclusive = true){
		var num = this;
		if (inclusive) {
			if (min > max) {
				return (num >= max && num <= min);
			}
			return (num >= min && num <= max);
		}
		
		if (min > max) {
			return (num > max && num < min);
		}
		return (num > min && num < max);
	},
	isWithinArray: function(arr){
		var slot = this;
		
		// no, if array empty / index negative / index more than last slot
		var len = arr.length;
		if (len === 0 || slot < 0 || slot >= len) {
			return false;
		}
		
		// else yes
		return true;
	},
	/** Checks if the value is > min and < max */
	isBetween: function(min, max){
		var num = this;
		return (num > min && num < max);
	},
	isOutside: function(min, max, inclusive = true){
		var num = this;
		if (inclusive) {
			return num <= min || num >= max;
		}
		return num < min || num > max;
	},
	isFractional: function(){
		var num = this;
		return int(num) != num;
	},
	isInteger: function(){
		var num = this;
		return int(num) == num;
	},
	
	
	// HEX
	toHex: function(digits = 6, withHash = true){
		var num = this;
		var zeros = ("0000000000000000000000000000000000").substr(0, digits - 1);
		return ((withHash ? "#" : "") + (zeros + num.toString(16).toUpperCase()).substr( -digits));
	},
	
	incrementWithin: function(min, max){
		var num = this;
		num++;
		if (num > max) {
			return min;
		}
		return num;
	},
	decrementWithin: function(min, max){
		var num = this;
		num--;
		if (num < min) {
			return max;
		}
		return num;
	},
	
	
	decimalToBinary: function(digits = 8){
		var num = this;
		var zeros = UB.decZeros.substr(0, digits - 1);
		return (zeros + num.toString(2)).substr( -digits);
	}, 
	decimalToBinary2: function(digits = 8){
		var byte = this;
		var bin = '';
		for (var i = 0;i<digits;i++){
			bin += String((byte & (0x80 >> i)) >> (7 - i));
		}
		return bin;
	},
	
	
	
	// MISC MATH
	pad: function(length, addToEnd = false, padChar = '0'){
		var number = this;
		
		// num to text
		var result = String(number);
		
		// exit quickly if already reached target len
		if (result.length >= length) {
			return result;
		}
		
		
		// pad
		if (addToEnd) {
			while (result.length < length){
				result = result + padChar;
			}
		}else {
			while (result.length < length){
				result = padChar + result;
			}
		}
		
		
		return result;
	},
	interpolate: function(min, max){
		var progress = this;
		// progress = (0 to 1)
		/*return( (1 - progress) * min + progress * max ); <---- WHAT IS THIS??? */ 
		return min + ((max - min) * progress);
	},
	hypot: function(b){
		var a = this;
		// sqrt(a^2 + b^2) without under/overflow.
		
		var r;
		var aAbs = (a > 0 ? a : -a);
		var bAbs = (b > 0 ? b : -b);
		if (aAbs > bAbs) {
			r = b/a;
			r = aAbs*Math.sqrt(1+r*r);
		} else if (b != 0) {
			r = a/b;
			r = bAbs*Math.sqrt(1+r*r);
		} else {
			r = 0.0;
		}
		return r;
	},
	apow: function(value){
		var pow = this;
		// input:	1,2,4,8,16,32,64
		// output:	1,2,3,4,5,6,7
		if (value == 1 || value === -1) return value;
if (a > 0)
    b = 42;
		var count = 0;
		while (value != 0) {
			//remainder = value % pow;
			value = value / pow;
			count++;
		}
		return count;
	},
	invert: function(){
		var value = this;
		// input:	0.1		0.5		1 	2 		8
		// output:	10		2		1	0.5		0.2
		return 1 / value;
	},
	powAbs: function(exponent){
		var x = this;
		// This function always returns a positive value that conforms to the expected Exponent curve.
		// Math.pow: If x is negative, and exponent is not an integer, returns NaN.
		if( x >= 0 ) {
			return Math.pow( x, exponent );
		}
		return Math.pow(-x, 1/exponent);
	},
	
	// count digits in number
	getWhole: function(){
		var val = this;
		
		// -10.235 has 2 whole digits
		return int(val);
	},
	setWhole: function(newval){
		var val = this;
		return newval + GetFractional(val);
	},
	getFractional: function(){
		var val = this;
		
		// -10.235 has 3 fractional digits
		var s = (val < 0 ? -val : val).toString();
		var i = s.indexOf(".");
		return (i === -1) ? int(val) : int(s.substr(i + 1));
	},
	setFractional: function(fraction){
		var val = this;
		return Number((parseInt(val).toString()) + "." + fraction.toString());
	},
	
	
	
	// SLOT INDEX
	minIndex: function(index2){
		var index1 = this;
		if (index1 <= -1) {
			return index2;
		}
		if (index2 <= -1) {
			return index1;
		}
		if (index1 < index2) {
			return index1;
		}
		return index2;
	},
	maxIndex: function(index2){
		var index1 = this;
		if (index1 <= -1) {
			return index2;
		}
		if (index2 <= -1) {
			return index1;
		}
		if (index1 > index2) {
			return index1;
		}
		return index2;
	},
	
	
	
	none:null
};

// register funcs
UB.registerFuncs(Number.prototype, numberFuncs);


nightfury7 / universalbasics.js

Push — master ( 8d43c8...457e33 )

numberFuncs.sqrt A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
